home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / c / amivogl-1.03.lzh / vogl / drivers / apollo.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-04-15  |  11.6 KB  |  589 lines
  1. /*
  2.  *    Apollo driver for vogl.
  3.  */
  4.  
  5. #include "/sys/ins/base.ins.c"
  6. #include "/sys/ins/gpr.ins.c"
  7. #include "/sys/ins/pad.ins.c"
  8. #include "/sys/ins/kbd.ins.c"
  9. #include <stdio.h>
  10. #include "vogl.h"
  11.  
  12. #define FONTBASE "/sys/dm/fonts/"
  13.  
  14. #define MAXCOLORS        256
  15. #define MIN(x,y)        ((x) < (y) ? (x) : (y))
  16. #define COLOR_ENTRY(r, g, b)    (gpr_$pixel_value_t) ((r << 16) | (g << 8) | b)
  17.  
  18. static ios_$id_t        stream_id;
  19. static gpr_$pixel_value_t      color_value[MAXCOLORS];
  20. static gpr_$pixel_value_t      old_color_value[MAXCOLORS];
  21.  
  22. static gpr_$offset_t            init_bitmap_size;   
  23. static gpr_$bitmap_desc_t       current_bitmap, front_bitmap, back_bitmap;       
  24. static gpr_$attribute_desc_t       attribs;
  25. static gpr_$window_t           source;
  26. static gpr_$position_t           dest_pos;
  27.  
  28. static gpr_$display_mode_t      mode = gpr_$direct;
  29. static gpr_$plane_t             hi_plane_id = 0;    
  30. static boolean                  delete_display;    
  31. static status_$t                status;
  32. static gpr_$keyset_t            keys, mouse_keys;
  33.  
  34. static pad_$window_list_t     window_info;
  35. static short             n_windows;
  36. static gpr_$disp_char_t        disp;
  37. static short            disp_len;
  38.  
  39. static int             first_time, back_used;
  40. static int             current_color;
  41. static short             font_id;
  42.  
  43. /*
  44.  * Do nothing
  45.  *
  46.  */
  47. int noop(void)
  48. {
  49.     return(-1);
  50. }
  51.  
  52. /*
  53.  * APOLLO_init
  54.  *
  55.  *    initialises window to occupy current window
  56.  */
  57. int APOLLO_init(void)
  58. {
  59.     pad_$window_desc_t     window;
  60.     int     size, prefx, prefy, prefxs, prefys, x, y, w, h;
  61.     short     i;
  62.  
  63.     pad_$set_scale(stream_$stdout,
  64.                1,
  65.                1,
  66.                status);
  67.  
  68.     pad_$inq_windows(stream_$stdout,
  69.              window_info,
  70.                   10,
  71.                n_windows,
  72.                  status);
  73.  
  74.     w = window_info[0].width;
  75.     h = window_info[0].height;
  76.     x = window_info[0].left;
  77.     y = window_info[0].top;
  78.  
  79.     getprefposandsize(&prefx, &prefy, &prefxs, &prefys);
  80.  
  81.     if (prefx > -1) {
  82.         x = prefx;
  83.         y = prefy;
  84.     }
  85.  
  86.     if (prefxs > -1) {
  87.         w = prefxs;
  88.         h = prefys;
  89.     }
  90.  
  91.     size = MIN(w, h);
  92.     vdevice.sizeX = vdevice.sizeY = size - 1;
  93.     vdevice.sizeSx = w - 1;
  94.     vdevice.sizeSy = h - 1;
  95.  
  96.         init_bitmap_size.x_size = w;
  97.         init_bitmap_size.y_size = h;
  98.  
  99.     source.window_base.x_coord = source.window_base.y_coord = 0;
  100.     source.window_size.x_size = init_bitmap_size.x_size;
  101.     source.window_size.y_size = init_bitmap_size.y_size;
  102.     dest_pos.x_coord = dest_pos.y_coord = 0;
  103.  
  104.     /*
  105.      * Inquire about the actual display ....
  106.      */
  107.  
  108.     gpr_$inq_disp_characteristics(mode,
  109.                       stream_$stdout,
  110.                       (short)60,
  111.                       disp,
  112.                       disp_len,
  113.                       status);
  114.  
  115.     vdevice.depth = disp.n_planes;
  116.     hi_plane_id = disp.n_planes - 1;
  117.  
  118.     if (prefx == -1 && prefxs == -1) {
  119.         stream_id = stream_$stdout;
  120.     } else {
  121.         window.top = y;
  122.         window.left = x;
  123.         window.width = w;
  124.         window.height = h;
  125.  
  126.         pad_$create_window("", 0,
  127.                 pad_$transcript, 
  128.                 1, 
  129.                 window,
  130.                 stream_id,
  131.                 status
  132.         );
  133.  
  134.         pad_$set_auto_close(stream_id, 1, true, status);
  135.     }
  136.  
  137.         gpr_$init(mode,
  138.                   stream_id,
  139.                   init_bitmap_size,
  140.                   hi_plane_id,
  141.                   front_bitmap,
  142.                   status);
  143.  
  144.     current_bitmap = front_bitmap;
  145.  
  146.     gpr_$set_auto_refresh(true, status);
  147.   
  148.     gpr_$set_cursor_active(false,status);
  149.  
  150.     /*  Set up all the character stuff  */
  151.  
  152.     first_time = 1;
  153.  
  154.     /*  create a key set for the event interupts  */
  155.  
  156.     lib_$init_set(keys, (short)256);
  157.     lib_$init_set(mouse_keys, (short)6);
  158.  
  159.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1D);
  160.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2D);
  161.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3D);
  162.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M1U);
  163.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M2U);
  164.     lib_$add_to_set(mouse_keys, (short)6, KBD_$M3U);
  165.  
  166.     for (i = 0; i < 128; i++) 
  167.         lib_$add_to_set(keys, (short)256, (short)i);
  168.  
  169.     gpr_$enable_input(gpr_$keystroke, keys, status);
  170.     gpr_$enable_input(gpr_$buttons, keys, status);
  171.     gpr_$enable_input(gpr_$locator, keys, status);
  172.  
  173.     /*  set default color (colour)   */
  174.  
  175.     if (disp.n_planes > 1) {
  176.         gpr_$inq_color_map(0L, (short)MAXCOLORS, old_color_value, status);
  177.         gpr_$inq_color_map(0L, (short)MAXCOLORS, color_value, status);
  178.  
  179.         color_value[0] = COLOR_ENTRY(0,0,0);         /* color--black   */
  180.         color_value[1] = COLOR_ENTRY(255,0,0);       /* color--red     */
  181.         color_value[2] = COLOR_ENTRY(0,255,0);       /* color--green   */
  182.         color_value[3] = COLOR_ENTRY(255,255,0);     /* color--yellow  */
  183.         color_value[4] = COLOR_ENTRY(0,0,255);       /* color--blue    */
  184.         color_value[5] = COLOR_ENTRY(255,0,255);     /* color--magenta */
  185.         color_value[6] = COLOR_ENTRY(0,255,255);     /* color--cyan    */
  186.         color_value[7] = COLOR_ENTRY(255,255,255);   /* color--white   */
  187.  
  188.         /* modify color table */
  189.         gpr_$acquire_display(status);
  190.         gpr_$set_color_map((long)0,
  191.                     (short)MAXCOLORS,
  192.                     color_value,
  193.                     status);
  194.         gpr_$release_display(status);
  195.     }
  196.  
  197.     back_used = 0;
  198.  
  199.     return(1);
  200. }
  201.  
  202.  
  203. /*
  204.  * APOLLO_draw
  205.  *
  206.  *    Draw a lines from the current graphics position to (x, y).
  207.  */
  208. int APOLLO_draw(
  209.   int x,
  210.   int y)
  211. {
  212.     gpr_$acquire_display(status);
  213.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  214.     gpr_$line((short)x, (short)(vdevice.sizeSy - y), status);
  215.     gpr_$release_display(status);
  216.     vdevice.cpVx = x;
  217.     vdevice.cpVy = y;
  218. }
  219.  
  220. /*
  221.  * APOLLO_getkey
  222.  *
  223.  *    grab a character from the keyboard
  224.  */
  225. int APOLLO_getkey(void)
  226. {
  227.     gpr_$event_t     et;
  228.     char         ed;
  229.     gpr_$position_t  pos;
  230.  
  231.  
  232.     et = gpr_$no_event;
  233.     while (et != gpr_$keystroke)
  234.         (void)gpr_$event_wait(et, ed, pos, status);
  235.  
  236.     /*
  237.      * What for this stupid gpr event system map the return key
  238.      * to a SYN character
  239.      */
  240.  
  241.     if ((ed & 0x7f) == 0x16)
  242.         ed = 13;
  243.  
  244.     return(ed);
  245. }
  246.  
  247. /*
  248.  * APOLLO_checkkey
  249.  *
  250.  *    checks if there is key waiting in the keyboard
  251.  */
  252. int APOLLO_checkkey(void)
  253. {
  254.     gpr_$event_t     et;
  255.     char             ed;
  256.     gpr_$position_t  pos;
  257.  
  258.     et = gpr_$no_event;
  259.  
  260.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  261.  
  262.     return((et == gpr_$keystroke ? 1 : 0));
  263. }
  264.  
  265. /*
  266.  * APOLLO_locator
  267.  *
  268.  *      return the window location of the cursor, plus which mouse button,
  269.  * if any, is been pressed.
  270.  *
  271.  *    LOCATOR - needs to return straight away.
  272.  */
  273. int APOLLO_locator(
  274.   int *wx,
  275.   int *wy)
  276. {
  277.     gpr_$event_t     et;
  278.     char             ed;
  279.     gpr_$position_t  pos;
  280.     gpr_$position_t  origin;
  281.  
  282.     gpr_$bitmap_desc_t    curs_pat;
  283.     gpr_$raster_op_array_t    curs_raster_op;
  284.     boolean            active;
  285.     
  286.  
  287.  
  288.     (void)gpr_$cond_event_wait(et, ed, pos, status);
  289.  
  290.     gpr_$inq_cursor(curs_pat, curs_raster_op, active, pos, origin, status);
  291.  
  292.     *wx = (int)pos.x_coord;
  293.     *wy = (int)vdevice.sizeSy - (int)pos.y_coord;
  294.  
  295.     if (ed < 'a')            /* absorb button up */
  296.         return(0);
  297.  
  298.     return(1 << ((int)ed - 'a'));
  299. }
  300.  
  301. /*
  302.  * APOLLO_clear
  303.  *
  304.  *    clear the window to the current color.
  305.  */
  306. int APOLLO_clear(void)
  307. {
  308.         int     x[4], y[4];
  309.  
  310.         if (vdevice.maxVx != vdevice.sizeSx
  311.            || vdevice.maxVy != vdevice.sizeSy
  312.            || vdevice.minVx != 0
  313.            || vdevice.minVy != 0) {
  314.         x[0] = x[3] = vdevice.minVx;
  315.         y[0] = y[1] = vdevice.maxVy;
  316.         y[2] = y[3] = vdevice.minVy;
  317.         x[1] = x[2] = vdevice.maxVx;
  318.  
  319.                 APOLLO_fill(4, x, y);
  320.         } else {
  321.         gpr_$acquire_display(status);
  322.         gpr_$clear((long)current_color, status);
  323.         gpr_$release_display(status);
  324.         }
  325.  
  326. }
  327.  
  328. /*
  329.  * APOLLO_exit
  330.  *
  331.  *    reset the window back to normal mode (sigh)
  332.  */
  333. int APOLLO_exit(void)
  334. {
  335.     if (disp.n_planes > 1) {
  336.         gpr_$acquire_display(status);
  337.         gpr_$set_color_map((long)0,
  338.                     (short)MAXCOLORS,
  339.                     old_color_value,
  340.                     status);
  341.         gpr_$release_display(status);
  342.     }
  343.     gpr_$terminate(delete_display,status); /*Terminate gpr.*/
  344. }
  345.  
  346. /*
  347.  * APOLLO_color
  348.  *
  349.  *    change the drawing color.
  350.  */
  351. int APOLLO_color(int ind)
  352. {
  353.     if (disp.n_planes <= 1) {
  354.         if (ind > 0)
  355.             current_color = 1;
  356.  
  357.         if (disp.invert)
  358.             current_color = !current_color;
  359.  
  360.     } else {
  361.         current_color = ind % MAXCOLORS;
  362.     }
  363.  
  364.     gpr_$set_draw_value((int)current_color, status); 
  365.     gpr_$set_text_value((int)current_color, status);
  366.     gpr_$set_fill_value((int)current_color, status);
  367.     /*
  368.      * GPR manual says that this sets text background to
  369.      * 'transparent'
  370.      */
  371.     gpr_$set_text_background_value((int)-1, status);
  372. }
  373.  
  374. /*
  375.  * APOLLO_mapcolor
  376.  *
  377.  *    set a colormap entry.
  378.  */
  379. int APOLLO_mapcolor(
  380.   int in,
  381.   short r,
  382.   short g,
  383.   short b)
  384. {
  385.     if (in < 0 || in > MAXCOLORS)
  386.         verror("APOLLO_mapcolor: index out of range");
  387.     
  388.     color_value[in] = COLOR_ENTRY(r, g, b);
  389.  
  390.     /* modify color table */
  391.  
  392.     gpr_$acquire_display(status);
  393.     gpr_$set_color_map((long)0,
  394.                 (short)MAXCOLORS,
  395.                 color_value,
  396.                 status);
  397.     gpr_$release_display(status);
  398. }
  399.  
  400. /*
  401.  * APOLLO_fill
  402.  *
  403.  *    draw a filled polygon
  404.  */
  405. int APOLLO_fill(
  406.   int n,
  407.   int *x,
  408.   int *y)
  409. {
  410.     short     nx[256], ny[256], startx, starty;
  411.     int    i;
  412.  
  413.     for (i = 1; i < n; i++) {
  414.         ny[i-1] = vdevice.sizeSy - y[i];
  415.         nx[i-1] = x[i];
  416.     }
  417.  
  418.     startx = x[0];
  419.     starty = vdevice.sizeSy - y[0];
  420.  
  421.     gpr_$acquire_display(status);
  422.     gpr_$start_pgon(startx, starty, status);
  423.  
  424.     gpr_$pgon_polyline(nx, ny, (short)(n - 1), status);
  425.     gpr_$close_fill_pgon(status);
  426.     gpr_$release_display(status);
  427. }
  428.  
  429. /*
  430.  * APOLLO_font
  431.  *
  432.  *    load in a hardware font
  433.  */
  434. int APOLLO_font(char *fontfile)
  435. {
  436.     gpr_$offset_t start;
  437.     short xy_end;
  438.     char    buf[256];
  439.  
  440.     if (first_time) {
  441.         gpr_$unload_font_file(font_id, status);
  442.         first_time = 0;
  443.     }
  444.  
  445.     strcpy(buf, FONTBASE);
  446.     strcat(buf, fontfile);
  447.     gpr_$load_font_file(buf, (short)strlen(buf), font_id, status);
  448.  
  449.     if (status.all) 
  450.         return (0);
  451.  
  452.     gpr_$set_text_font(font_id, status);
  453.  
  454.     /* see above comment about &'s */
  455.  
  456.     gpr_$inq_text_offset("H", (short)1, start, xy_end, status);
  457.  
  458.     vdevice.hwidth = xy_end;
  459.     vdevice.hheight = start.y_size;
  460.  
  461.     return (1);
  462. }
  463.  
  464. /*
  465.  * APOLLO_char
  466.  *
  467.  *    output a character
  468.  */
  469. int APOLLO_char(char c)
  470. {
  471.     char s[2];
  472.     s[1] = '\0';
  473.     s[0] = c;
  474.     gpr_$acquire_display(status);
  475.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  476.     gpr_$text(s[0], (short)1, status);
  477.     gpr_$release_display(status);
  478. }
  479.  
  480. /*
  481.  * APOLLO_string
  482.  *
  483.  *    display a string
  484.  */
  485. int APOLLO_string(char s[])
  486. {
  487.     short    len;
  488.  
  489.     len = (short)strlen(s);
  490.     gpr_$acquire_display(status);
  491.     gpr_$move((short)vdevice.cpVx, (short)(vdevice.sizeSy - vdevice.cpVy), status);
  492.     gpr_$text(s[0], len, status);
  493.     gpr_$release_display(status);
  494. }
  495.  
  496. /*
  497.  * APOLLO_backb
  498.  *
  499.  *    Allocates and sets the back display buffer.
  500.  */
  501. int APOLLO_backb(void)
  502. {
  503.     if (!back_used) {
  504.         gpr_$allocate_attribute_block(attribs, status);
  505.         gpr_$allocate_bitmap(init_bitmap_size, (short)hi_plane_id, attribs, back_bitmap, status);
  506.         gpr_$enable_input(gpr_$keystroke, keys, status);
  507.         gpr_$enable_input(gpr_$buttons, keys, status);
  508.         gpr_$enable_input(gpr_$locator, keys, status);
  509.         back_used = 1;
  510.         if (status.all) {
  511.             fprintf(stderr, "APOLLO_backb: problem (status = %d)\n", status);
  512.             error_$print(status);
  513.             return(-1);
  514.         }
  515.     }
  516.  
  517.     gpr_$set_bitmap(back_bitmap, status);
  518.     gpr_$set_color_map((long)0,
  519.                 (short)MAXCOLORS,
  520.                 color_value,
  521.                 status);
  522.  
  523.     current_bitmap = back_bitmap;
  524.  
  525.     return(1);
  526. }
  527.  
  528. /*
  529.  * APOLLO_swapb
  530.  *
  531.  *    Swap the front and back buffers' role - actually just copy
  532.  *    the back buffer to the display buffer.
  533.  */
  534. int APOLLO_swapb(void)
  535. {
  536.     gpr_$acquire_display(status);
  537.     gpr_$set_bitmap(front_bitmap, status);
  538.     gpr_$pixel_blt(back_bitmap, source, dest_pos, status);
  539.     gpr_$set_bitmap(back_bitmap, status);
  540.     gpr_$release_display(status);
  541. }
  542.  
  543. /*
  544.  * APOLLO_frontb
  545.  *
  546.  *    Make sure we are drawing in the front (display) buffer
  547.  */
  548. int APOLLO_frontb(void)
  549. {
  550.     current_bitmap = front_bitmap;
  551.     gpr_$set_bitmap(front_bitmap, status);
  552. }
  553.  
  554.  
  555. static DevEntry apdev = {
  556.     "apollo",
  557.     "f16.b",
  558.     "f7x13.b",
  559.     APOLLO_backb,
  560.     APOLLO_char,
  561.     APOLLO_checkkey,
  562.     APOLLO_clear,
  563.     APOLLO_color,
  564.     APOLLO_draw,
  565.     APOLLO_exit,
  566.     APOLLO_fill,
  567.     APOLLO_font,
  568.     APOLLO_frontb,
  569.     APOLLO_getkey,
  570.     APOLLO_init,
  571.     APOLLO_locator,
  572.     APOLLO_mapcolor,
  573.     noop,
  574.     noop,
  575.     APOLLO_string,
  576.     APOLLO_swapb,
  577.     noop
  578. };
  579.  
  580. /*
  581.  * _APOLLO_devcpy
  582.  *
  583.  *      copy the apollo device into vdevice.dev.
  584.  */
  585. int _APOLLO_devcpy(void)
  586. {
  587.     vdevice.dev = apdev;
  588. }
  589.